#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define KEY_CNT   1  // 设备号个数
#define KEY_NAME  "key" // 名字

#define KEY0VALUE  0xf0 // 按键值
#define INVAKEY    0x00 // 无效按键值

/* 设备结构体 */
struct key_dev{
    dev_t devid;                   // 设备号
    struct cdev cdev;             // cdev
    struct class* class;         // 类
    struct device* device;       // 设备
    int major;                  // 主设备号
    int minor;                 // 次设备号
    struct device_node* nd;   // 设备节点
    int key_gpio;            // key所使用的gpio编号
    atomic_t  keyvalue;     // 按键值
};

static struct key_dev keydev;  // 按键值

static int keyio_init(void){
  int ret;
  const char* str;
  /*设置LED所使用GPIO*/
  // 1.获取节点keydev
  keydev.nd = of_find_node_by_path("/key");
  if(keydev.nd == NULL){
    printk("keydev node not find! \r\n");
    return -1;
  }
  
  // 2.读取status属性
  ret = of_property_read_string(keydev.nd, "status", &str);
  if(ret < 0) return -1;
  if(strcmp(str, "okay")) return -1;

  // 3.获取compatible属性并对比
  ret = of_property_read_string(keydev.nd, "compatible", &str);
  if(ret < 0){
    printk("failed to get compatible\n");
    return -1;
  }

  if(strcmp(str, "alientek,key")){
    printk("compatible match failed\n");
    return -1;
  }

  // 4.获取gpio属性，得到kEY编号
  keydev.key_gpio = of_get_named_gpio(keydev.nd, "key-gpio", 0);
  if(keydev.key_gpio < 0){
    printk("cant get key-gpio \n");
    return -1;
  }
  printk("key-gpio num= %d \n", keydev.key_gpio);

  // 5.向gpio子系统申请使用gpio
  ret = gpio_request(keydev.key_gpio, "KEY0");
  if(ret){
    printk("failed to request key-gpio \n");
    return ret;
  }

  // 6.设置gpio输入模式
  ret = gpio_direction_input(keydev.key_gpio);
  if(ret < 0){
    printk("cant set gpio \n");
    return ret;
  }

  return 0;
}

static int key_open(struct inode* inode, struct file* filp){
  int ret = 0;
  filp->private_data = &keydev;
  ret = keyio_init();
  if(ret < 0) return ret;
  
  return 0;
}

static ssize_t key_read(struct file* filp, char __user* buf, size_t cnt, loff_t* offt){
  int ret = 0;
  int value;
  struct key_dev* dev = filp->private_data;
  if(gpio_get_value(dev->key_gpio) == 1){
    while(gpio_get_value(dev->key_gpio));
    atomic_set(&dev->keyvalue, KEY0VALUE);
  }else{
    atomic_set(&dev->keyvalue, INVAKEY);
  }

  value = atomic_read(&dev->keyvalue);
  ret = copy_to_user(buf, &value, sizeof(value));
  return ret;
}

static ssize_t key_write(struct file* filp, const char __user* buf, size_t cnt, loff_t* offt){
  return 0;
}

static int key_release(struct inode* inode, struct file* filp){
  struct key_dev* dev = filp->private_data;
  gpio_free(dev->key_gpio);
  return 0;
}
// 设备操作函数
static struct file_operations key_fops = {
  .owner = THIS_MODULE,
  .open = key_open,
  .read = key_read,
  .write = key_write,
  .release = key_release,
};



/* 驱动入口 */
static int __init mykey_init(void){
  int ret;
  
  // 1.初始化原子变量
  keydev.keyvalue = (atomic_t)ATOMIC_INIT(0);
  // 2.初始值设置为INVAKEY
  atomic_set(&keydev.keyvalue, INVAKEY);

  /*注册字符驱动*/
  // 1.创建设备号
  if(keydev.major){ // 定义了设备号
    keydev.devid = MKDEV(keydev.major, 0);
    ret = register_chrdev_region(keydev.devid, KEY_CNT, KEY_NAME);
    if(ret < 0){
      printk("cannt register %s char driver \n", KEY_NAME);
      return -1;
    }
  }else{ // 未定义设备号
    ret = alloc_chrdev_region(&keydev.devid, 0, KEY_CNT, KEY_NAME); // 申请设备号
    if(ret < 0){
      printk("%s couldnot alloc_chrdev_region \n", KEY_NAME);
      return -1;
    }
    keydev.major = MAJOR(keydev.devid); // 分配主设备号
    keydev.minor = MINOR(keydev.devid); // 分配次设备
  }
  printk("keydev major=%d, minor=%d \r\n", keydev.major, keydev.minor);
  
  // 2.初始化cdev
  keydev.cdev.owner = THIS_MODULE;
  cdev_init(&keydev.cdev, &key_fops);

  // 3.添加一个cdev
  ret = cdev_add(&keydev.cdev, keydev.devid, KEY_CNT);
  if(ret < 0) goto del_unregister;

  // 4.创建类
  keydev.class = class_create(THIS_MODULE, KEY_NAME);
  if(IS_ERR(keydev.class)) goto del_cdev;

  // 5.创建设备
  keydev.device = device_create(keydev.class, NULL, keydev.devid, NULL, KEY_NAME);
  if(IS_ERR(keydev.device)) goto destroy_class; 

  return 0;
destroy_class:
  device_destroy(keydev.class, keydev.devid);
del_cdev:
  cdev_del(&keydev.cdev);  
del_unregister:
  unregister_chrdev_region(keydev.devid, KEY_CNT);
  return -1;
}

/* 驱动出口 */
static void __exit mykey_exit(void){
  // 注销字符设备驱动
  cdev_del(&keydev.cdev); // 删除cdev
  unregister_chrdev_region(keydev.devid, KEY_CNT); // 注销设备号

  device_destroy(keydev.class, keydev.devid);
  class_destroy(keydev.class);
}

module_init(mykey_init);
module_exit(mykey_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Narnat");
